
package com.weplay.gameplane.utils;

import android.text.TextUtils;

import java.text.DecimalFormat;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
import java.util.regex.Matcher;
import java.util.regex.Pattern;


public class StringUtils {

    /**
     * 字符串 空指针处理
     * @param mString
     * @return  为空时，默认返回值
     */
    public static boolean isEmpty(String mString){
        if ("null".equals(mString)){
            return true;
        }
        return TextUtils.isEmpty(mString);
    }

    /**
     * 字符串 空指针处理
     * @param mString
     * @return  为空时，默认返回值
     */
    public static boolean isEmptyWu(String mString){
        if ("null".equals(mString)){
            return true;
        }else if ("无".equals(mString)){
            return true;
        }
        return TextUtils.isEmpty(mString);
    }

    /**
     * 字符串 空指针处理
     * @param mString
     * @return  为空时，默认返回值
     */
    public static boolean isNoEmpty(String mString){
        if (!"null".equals(mString) && !TextUtils.isEmpty(mString)){
            return true;
        }
        return false;
    }

    /**
     * 字符串 大于0 的
     * @param mString
     * @return
     */
    public static String getStringGreater0(int mString){
        if (mString > 0){
            return getString(String.valueOf(mString),"");
        }else {
            return "";
        }
    }


    /**
     * 字符串 空指针处理
     * @param mString
     * @return
     */
    public static String getStringGreater0(int mString,String defaultStr){
        if (mString > 0){
            return getString(String.valueOf(mString),"");
        }else {
            return defaultStr;
        }
    }


    /**
     * 字符串 空指针处理
     * @param mString
     * @return
     */
    public static String getString(int mString){
        return getString(String.valueOf(mString),"");
    }


    /**
     * 字符串 空指针处理
     * @param data
     * @return
     */
    public static String getString(Object data){
        try{
            return  getString(String.valueOf(data),"");
        }catch (Exception e){
        }
        return "";
    }


    /**
     * 字符串 空指针处理
     * @param mString
     * @return
     */
    public static String getString(int mString ,String defaultStr){
        return getString(String.valueOf(mString), defaultStr);
    }

    /**
     * 字符串 空指针处理
     * @param mString
     * @return
     */
    public static String getString(long mString){
        return getString(String.valueOf(mString),"");
    }


    /**
     * 字符串 空指针处理
     * @param mString
     * @return
     */
    public static String getString(String mString){
        return getString(mString,"");
    }
    /**
     * 字符串 空指针处理
     * @param mdouble
     * @return
     */
    public static String getString(Double mdouble){
        return getString(mdouble,"0");
    }


    /**
     * 字符串 空指针处理
     * @param mString
     * @return  为空时，默认返回值
     */
    public static String getString(String mString,String defaultStr){
        if ("null".equals(mString)){
            return defaultStr;
        }
        return TextUtils.isEmpty(mString)? defaultStr:mString;
    }



    /**
     * 字符串 空指针处理
     * @param mdouble
     * @return  为空时，默认返回值
     */
    public static String getString(Double mdouble,String defaultStr){
        if (mdouble==null){
            return defaultStr;
        }
        return String.valueOf(mdouble);
    }

    /**
     * 字符串 空指针处理
     * @param mInt
     * @return  为空时，默认返回值
     */
    public static int getInt(String mInt){
        return getInt(mInt,0);
    }



    /**
     * 字符串 空指针处理
     * @param mInt
     * @return  为空时，默认返回值
     */
    public static int getInt(String mInt,int defaultStr){
        if ( TextUtils.isEmpty(mInt)){
            return defaultStr;
        }
        int value = defaultStr;
        try{
            value =  Integer.parseInt(mInt);
        }catch (Exception exceptione){
        }
        return value;
    }


    /**
     * 字符串 空指针处理
     * @param mInt
     * @return  为空时，默认返回值
     */
    public static int getInt(float mInt){
        int value = (int) mInt;
        return value;
    }

    /**
     * 字符串 空指针处理
     * @param mInt
     * @return  为空时，默认返回值
     */
    public static int getInt(double mInt){
        int value = (int) mInt;
        return value;
    }


    /**
     * 字符串 空指针处理
     * @param mfloat
     * @return  为空时，默认返回值
     */
    public static float getFloat(String mfloat){
        return getFloat(mfloat, 0);
    }

    /**
     * 字符串 空指针处理
     * @param mfloat
     * @return  为空时，默认返回值
     */
    public static float getFloat(String mfloat,float defaultStr){
        if ( TextUtils.isEmpty(mfloat)){
            return defaultStr;
        }
        float value = defaultStr;
        try{
            value =  Float.parseFloat(mfloat);
        }catch (Exception exceptione){
        }
        return value;
    }


    /**
     * 字符串 空指针处理
     * @param mDouble
     * @return  为空时，默认返回值
     */
    public static double getDouble(String mDouble){
        return getFloat(mDouble, 0);
    }

    /**
     * 字符串 空指针处理
     * @param mDouble
     * @return  为空时，默认返回值
     */
    public static double getDouble(String mDouble,double defaultStr){
        if ( TextUtils.isEmpty(mDouble)){
            return defaultStr;
        }
        double value = defaultStr;
        try{
            value =  Double.parseDouble(mDouble);
        }catch (Exception exceptione){
        }
        return value;
    }




    /**
     * 验证是否是手机号码
     *
     * @param str 需要判断的字符串
     * @return 是手机号码返回true
     */
    public static boolean isNumber(String str) {
        double aDouble = StringUtils.getDouble(str, -9999f);
        if (aDouble != -9999f){
            return true;
        }
        return false;
    }

    /**
     * 验证是否是手机号码
     *
     * @param str 需要判断的字符串
     * @return 是手机号码返回true
     */
    public static boolean isPhoneNumber(String str) {
        if (isEmpty(str)){
            return false;
        }
        String regex = "^[1][345789][0-9]{9}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }

    /**
     * 判断是否是 座机 号码
     * @param phoneNumber
     * @return
     */
    public static boolean isZuoJiTelephone(String phoneNumber) {
        if (isEmpty(phoneNumber)){
            return false;
        }
        String regex = "^0(10|2[0-5789]-|\\d{3})-?\\d{7,8}$";
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(phoneNumber);
        return isPhone.matches();
    }

    /**
     * 验证是否是18位身份证号
     *
     * @param str 需要判断的字符串
     * @return 是18位身份证号返回true
     */
    public static boolean isIDCardNumber(String str) {
        if (isEmpty(str)){
            return false;
        }
        String regex = "^([1-6][1-9]|50)\\d{4}(18|19|20)\\d{2}((0[1-9])|10|11|12)(([0-2][1-9])|10|20|30|31)\\d{3}[0-9Xx]$";
        Pattern pattern = Pattern.compile(regex);
        Matcher isPhone = pattern.matcher(str);
        return isPhone.matches();
    }

    /***
     * 格式化 手机号 ， 中间 **** 隐藏
     * @param phoneNum
     * @return
     */
    public static String getFormatPhoneNum(String phoneNum){
        return getFormatPhoneNum(phoneNum,StringUtils.getString(phoneNum) + "");
    }

    /***
     * 格式化 手机号 ， 中间 **** 隐藏
     * @param phoneNum
     * @return
     */
    public static String getFormatPhoneNum(String phoneNum,String def){
        if (isEmpty(phoneNum) || !isPhoneNumber(phoneNum)){
            return def;
        }
        StringBuilder phonehint = new StringBuilder(phoneNum);
        return getString(phonehint.replace(3, 7, "****").toString());
    }

    public static String getFormatIDCardNum(String idNum){
        return getFormatIDCardNum(idNum,StringUtils.getString(idNum) + "");
    }
    /***
     * 格式化 手机号 ， 中间 **** 隐藏
     * @param idNum
     * @return
     */
    public static String getFormatIDCardNum(String idNum,String def){
        if (isEmpty(idNum) || !isIDCardNumber(idNum)){
            return def;
        }
        StringBuilder idNumHint = new StringBuilder(idNum);
        return getString(idNumHint.replace(3, 14, "***********").toString());
    }

    /** 小数格式化 **/
    public static String toFloatFormat1decimal(float value){
        float remainder = value - (int)value ;
        DecimalFormat df = new DecimalFormat("######0.0");
        if (remainder > 0){
            return df.format(value);
        }else {
            return (int)value + "";
        }
    }

    /** 小数格式化 **/
    public static String toFloatFormat2decimal(float value){
        float remainder = value - (int)value ;
        DecimalFormat df = new DecimalFormat("######0.00");
        if (remainder > 0){
            return df.format(value);
        }else {
            return (int)value + "";
        }
    }


    /**
     * 判断是不是json数据
     * @param str
     * @return
     */
    public static boolean isJsonFormat(String str) {
        boolean result = false;
        if (StringUtils.isNoEmpty(str)) {
            str = str.trim();
            if (str.startsWith("{") && str.endsWith("}")) {
                result = true;
            } else if (str.startsWith("[") && str.endsWith("]")) {
                result = true;
            }
        }
        return result;
    }


    public static List<String> removeDuplicateForList(List<String> list) {
        Set set = new LinkedHashSet<String>();
        set.addAll(list);
        list.clear();
        list.addAll(set);
        return list;
    }

    public static String formatNumDouble(String data){
        if (StringUtils.isEmpty(data)){
            return "0";
        }
        return formatNumDouble(data,"");
    }

    /**
     * 对数字进行格式化
     * @param data
     * @param formatStr
     * @return
     */
    public static String formatNumDouble(String data, String formatStr){
        if (StringUtils.isEmpty(data)){
            return "0";
        }
        DecimalFormat   df = new  DecimalFormat(StringUtils.getString(formatStr, "#.00"));
        return df.format(StringUtils.getDouble(data));
    }


    public static String formatNumDouble(double data){
        if (data == 0){
            return "0";
        }
        return formatNumDouble(data,"");
    }
    /**
     * 对数字进行格式化
     * @param data
     * @param formatStr
     * @return
     */
    public static String formatNumDouble(double data, String formatStr){
        if (data == 0){
            return "0";
        }
        DecimalFormat   df = new  DecimalFormat(StringUtils.getString(formatStr, "#0.00"));
        return df.format(data);
    }


}
